﻿using Util.ExtensionMethods;
using SupportLayer.Objetos.Produto;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using SupportLayer.Constantes.PRODUTO;
using SupportLayer.Objetos.Outros;
using SupportLayer.Constantes.OUTROS;
using SupportLayer.Objetos.Cliente;
using SupportLayer.Constantes.CLIENTE;
using SupportLayer.Objetos.Usuario;
using SupportLayer.Constantes.USUARIO;

namespace SupportLayer.ExtensionMethods
{
	public static class DataBase
	{
		#region Classes
		public static List<BannerClass> toBannerClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<BannerClass> lstBanner = new List<BannerClass>();

			foreach (DataRow dr in dt.Rows)
			{
				BannerClass banner = new BannerClass();

				banner.ID = Convert.ToInt32(dr[BANNER.ID].ToString());
				banner.ImageUrl = dr[BANNER.IMAGE_URL].ToString();
				banner.Ordem = Convert.ToInt16(dr[BANNER.ORDEM].ToString());
				lstBanner.Add(banner);
			}

			return lstBanner;
		}
		public static List<CategoriaClass> toCategoriaClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<CategoriaClass> lstCategoria = new List<CategoriaClass>();

			foreach (DataRow dr in dt.Rows)
			{
				CategoriaClass categoria = new CategoriaClass();

				categoria.ID = Convert.ToInt32(dr[CATEGORIA.ID].ToString());
				categoria.Descricao = dr[CATEGORIA.DESCRICAO].ToString();
				categoria.Tags = dr[CATEGORIA.TAGS].ToString();

				lstCategoria.Add(categoria);
			}

			return lstCategoria;
		}
		public static List<CategoriaMasterClass> toCategoriaMasterClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<CategoriaMasterClass> lstCategoriaMaster = new List<CategoriaMasterClass>();

			foreach (DataRow dr in dt.Rows)
			{
				CategoriaMasterClass categoria = new CategoriaMasterClass();

				categoria.ID = Convert.ToInt16(dr[CATEGORIA_MASTER.ID].ToString());
				categoria.Descricao = dr[CATEGORIA_MASTER.DESCRICAO].ToString();

				lstCategoriaMaster.Add(categoria);
			}

			return lstCategoriaMaster;
		}
		public static List<ClienteClass> toClienteClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<ClienteClass> lstClientes = new List<ClienteClass>();

			foreach (DataRow dr in dt.Rows)
			{
				ClienteClass cliente = new ClienteClass();

				cliente.ID = Convert.ToInt64(dr[CLIENTE.ID].ToString());
				cliente.Nome = dr[CLIENTE.NOME].ToString();
				cliente.Sobrenome = dr[CLIENTE.SOBRENOME].ToString();
				cliente.CPF = dr[CLIENTE.CPF].ToString();
				cliente.Sexo = Convert.ToChar(dr[CLIENTE.SEXO].ToString());
				cliente.DataNascimento = Convert.ToDateTime(dr[CLIENTE.DATA_NASCIMENTO].ToString());
				cliente.DDDTelefone = dr[CLIENTE.DDD_TELEFONE].ToString();
				cliente.Telefone = dr[CLIENTE.TELEFONE].ToString();
				cliente.DDDCelular = dr[CLIENTE.DDD_CELULAR].ToString();
				cliente.Celular = dr[CLIENTE.CELULAR].ToString();
				cliente.Email = dr[CLIENTE.EMAIL].ToString();
				cliente.Senha = dr[CLIENTE.SENHA].ToString();
				cliente.ReceberOfertas = Convert.ToBoolean(dr[CLIENTE.RECEBER_OFERTAS].ToString());
				cliente.Ativo = Convert.ToBoolean(dr[CLIENTE.ATIVO].ToString());

				lstClientes.Add(cliente);
			}

			return lstClientes;
		}
		public static List<ClienteCarrinhoClass> toCarrinhoClass(this DataTable dt)
		{
			if (dt.isNull())
				return new List<ClienteCarrinhoClass>();

			if (dt.Rows.Count == 0)
				return new List<ClienteCarrinhoClass>();

			List<ClienteCarrinhoClass> lstCarrinho = new List<ClienteCarrinhoClass>();

			foreach (DataRow dr in dt.Rows)
			{
				ClienteCarrinhoClass carrinho = new ClienteCarrinhoClass();

				carrinho.ID = Convert.ToInt64(dr[CLIENTE_CARRINHO.ID].ToString());
				carrinho.ClienteID = Convert.ToInt64(dr[CLIENTE_CARRINHO.CLIENTE_ID].ToString());
				carrinho.ProdutoID = Convert.ToInt64(dr[CLIENTE_CARRINHO.PRODUTO_ID].ToString());
				carrinho.EspecificacaoID = Convert.ToInt64(dr[CLIENTE_CARRINHO.ESPECIFICACAO_ID].ToString());
				carrinho.Quantidade = Convert.ToInt32(dr[CLIENTE_CARRINHO.QUANTIDADE].ToString());

				lstCarrinho.Add(carrinho);
			}

			return lstCarrinho;
		}
		public static List<CidadeClass> toCidadeClass(this DataTable dt)
		{
			if (dt.isNull())
				return new List<CidadeClass>();

			if (dt.Rows.Count == 0)
				return new List<CidadeClass>();

			List<CidadeClass> lstCidades = new List<CidadeClass>();

			foreach (DataRow dr in dt.Rows)
			{
				CidadeClass c = new CidadeClass();

				c.ID = Convert.ToInt64(dr[CIDADE.ID].ToString());
				c.EstadoID = Convert.ToInt64(dr[CIDADE.ESTADO_ID].ToString());
				c.Nome = dr[CIDADE.NOME].ToString();

				lstCidades.Add(c);
			}

			return lstCidades;
		}
		public static List<ContatoClass> toContatoClass(this DataTable dt)
		{
			try
			{
				if (dt.isNull())
					return null;

				if (dt.Rows.Count == 0)
					return null;

				List<ContatoClass> lstContatos = new List<ContatoClass>();

				foreach (DataRow dr in dt.Rows)
				{
					ContatoClass contato = new ContatoClass();

					contato.ID = Convert.ToInt32(dr[CONTATO.ID].ToString());
					contato.Assunto = dr[CONTATO.ASSUNTO].ToString();
					contato.Email = dr[CONTATO.EMAIL].ToString();
					contato.IP = dr[CONTATO.IP].ToString();
					contato.Mensagem = dr[CONTATO.MENSAGEM].ToString();
					contato.Nome = dr[CONTATO.NOME].ToString();
					contato.Telefone = dr[CONTATO.TELEFONE].ToString();

					lstContatos.Add(contato);
				}

				return lstContatos;
			}
			catch (Exception)
			{

				throw;
			}
		}
		public static List<DestaqueClass> toDestaqueClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<DestaqueClass> lstDestaque = new List<DestaqueClass>();

			foreach (DataRow dr in dt.Rows)
			{
				DestaqueClass destaque = new DestaqueClass();

				destaque.ID = Convert.ToInt16(dr[DESTAQUE.ID].ToString());
				destaque.Data = Convert.ToDateTime(dr[DESTAQUE.DATA].ToString());
				destaque.ProdutoID = Convert.ToInt64(dr[DESTAQUE.PRODUTO_ID].ToString());

				lstDestaque.Add(destaque);
			}

			return lstDestaque;
		}
		public static List<DimensoesClass> toDimensoesClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<DimensoesClass> lstDimensoes = new List<DimensoesClass>();

			foreach (DataRow dr in dt.Rows)
			{
				DimensoesClass dimensoes = new DimensoesClass();
				dimensoes.ID = Convert.ToInt64(dr[DIMENSOES.ID].ToString());
				dimensoes.Peso = Int64.Parse(dr[DIMENSOES.PESO].ToString());
				lstDimensoes.Add(dimensoes);
			}

			return lstDimensoes;
		}
		public static List<DividirClass> toDividirClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<DividirClass> lstDividir = new List<DividirClass>();

			foreach (DataRow dr in dt.Rows)
			{
				DividirClass dividir = new DividirClass();

				dividir.ID = Convert.ToInt16(dr[DIVIDIR.ID].ToString());
				dividir.Juros = Convert.ToInt32(dr[DIVIDIR.JUROS].ToString());
				dividir.MaximoParcelas = Convert.ToInt16(dr[DIVIDIR.PARCELAS].ToString());

				lstDividir.Add(dividir);
			}

			return lstDividir;
		}
		public static List<EnderecoClass> toEnderecoClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<EnderecoClass> lstEndereco = new List<EnderecoClass>();

			foreach (DataRow dr in dt.Rows)
			{
				EnderecoClass e = new EnderecoClass();

				e.ID = Convert.ToInt32(dr[ENDERECO.ID].ToString());
				e.Ativo = Convert.ToBoolean(dr[ENDERECO.ATIVO].ToString());
				e.Bairro = dr[ENDERECO.BAIRRO].ToString();
				e.CEP = dr[ENDERECO.CEP].ToString();
				e.CidadeID = Convert.ToInt64(dr[ENDERECO.CIDADE_ID].ToString());
				e.ClienteID = Convert.ToInt64(dr[ENDERECO.CLIENTE_ID].ToString());

				if (dr[ENDERECO.COMPLEMENTO] != null)
					e.Complemento = dr[ENDERECO.COMPLEMENTO].ToString();

				if (dr[ENDERECO.LOGRADOURO] != null)
					e.Logradouro = dr[ENDERECO.LOGRADOURO].ToString();

				e.Numero = dr[ENDERECO.NUMERO].ToString();
				e.Referencia = dr[ENDERECO.REFERENCIA].ToString();

				lstEndereco.Add(e);
			}

			return lstEndereco;
		}
		public static List<EspecificacaoClass> toEspecificacaoClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<EspecificacaoClass> lstEspecificacoes = new List<EspecificacaoClass>();

			foreach (DataRow dr in dt.Rows)
			{
				EspecificacaoClass especificacao = new EspecificacaoClass();

				especificacao.ID = Convert.ToInt32(dr[ESPECIFICACAO.ID].ToString());
				especificacao.CodigoLoja = dr[ESPECIFICACAO.CODIGO_LOJA].ToString();
				especificacao.Cor = dr[ESPECIFICACAO.COR].ToString();
				especificacao.Observacao = dr[ESPECIFICACAO.OBSERVACAO].ToString();
				especificacao.ProdutoID = Convert.ToInt64(dr[ESPECIFICACAO.PRODUTO_ID].ToString());
				especificacao.Quantidade = Convert.ToInt32(dr[ESPECIFICACAO.QUANTIDADE].ToString());
				especificacao.Tamanho = dr[ESPECIFICACAO.TAMANHO].ToString();

				lstEspecificacoes.Add(especificacao);
			}

			return lstEspecificacoes;
		}
		public static List<EstadoClass> toEstadoClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<EstadoClass> lstEstados = new List<EstadoClass>();

			foreach (DataRow dr in dt.Rows)
			{
				EstadoClass e = new EstadoClass();

				e.ID = Convert.ToInt32(dr[ESTADO.ID].ToString());
				e.Nome = dr[ESTADO.NOME].ToString();
				e.Pais = dr[ESTADO.PAIS].ToString();
				e.Sigla = dr[ESTADO.SIGLA].ToString();

				lstEstados.Add(e);
			}

			return lstEstados;
		}
		public static List<FotosClass> toFotosClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<FotosClass> lstFotos = new List<FotosClass>();

			foreach (DataRow dr in dt.Rows)
			{
				FotosClass foto = new FotosClass();

				foto.ID = Convert.ToInt32(dr[FOTOS.ID].ToString());
				foto.Caminho = dr[FOTOS.CAMINHO].ToString();
				foto.ProdutoID = Convert.ToInt64(dr[FOTOS.PRODUTO_ID].ToString());

				lstFotos.Add(foto);
			}

			return lstFotos;
		}
		public static List<MarcaClass> toMarcaClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<MarcaClass> lstMarcas = new List<MarcaClass>();

			foreach (DataRow dr in dt.Rows)
			{
				MarcaClass marca = new MarcaClass();

				marca.ID = Convert.ToInt32(dr[MARCA.ID].ToString());
				marca.Descricao = dr[MARCA.DESCRICAO].ToString();

				lstMarcas.Add(marca);
			}

			return lstMarcas;
		}
		public static List<PedidosClass> toPedidoClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<PedidosClass> lstPedido = new List<PedidosClass>();

			foreach (DataRow dr in dt.Rows)
			{
				PedidosClass pedido = new PedidosClass();

				pedido.ID = Convert.ToInt64(dr[PEDIDOS.ID].ToString());
				pedido.CarrinhoID = Convert.ToInt64(dr[PEDIDOS.CARRINHO_ID].ToString());
				pedido.CodigoPedido = dr[PEDIDOS.CODIGO_PEDIDO].ToString();

				lstPedido.Add(pedido);
			}

			return lstPedido;
		}
		public static List<ProdutoClass> toProdutoClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<ProdutoClass> lstProdutos = new List<ProdutoClass>();

			foreach (DataRow dr in dt.Rows)
			{
				ProdutoClass prod = new ProdutoClass();

				prod.ID = Convert.ToInt32(dr[PRODUTO.ID].ToString());
				prod.CategoriaID = Convert.ToInt32(dr[PRODUTO.CATEGORIA_ID].ToString());
				prod.CategoriaSecundariaID = Convert.ToInt32(dr[PRODUTO.CATEGORIA_SECUNDARIA_ID].ToString());
				prod.CategoriaMasterID = Convert.ToInt16(dr[PRODUTO.CATEGORIAMASTER_ID].ToString());
				prod.Data = Convert.ToDateTime(dr[PRODUTO.DATA].ToString());
				prod.Descricao = dr[PRODUTO.DESCRICAO].ToString();
				prod.DimensoesID = Convert.ToInt64(dr[PRODUTO.DIMENSOES_ID].ToString());
				prod.DividirID = Convert.ToInt64(dr[PRODUTO.DIVIDIR_ID].ToString());
				prod.Foto = dr[PRODUTO.FOTO].ToString();
				prod.MarcaID = Convert.ToInt32(dr[PRODUTO.MARCA_ID].ToString());
				prod.Modelo = dr[PRODUTO.MODELO].ToString();
				prod.Preco = Convert.ToDecimal(dr[PRODUTO.PRECO].ToString());

				lstProdutos.Add(prod);
			}

			return lstProdutos;
		}
		public static List<PromocaoClass> toPromocaoClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<PromocaoClass> lstPromocao = new List<PromocaoClass>();

			foreach (DataRow dr in dt.Rows)
			{
				PromocaoClass promocao = new PromocaoClass();

				promocao.ID = Convert.ToInt32(dr[PROMOCAO.ID].ToString());
				promocao.DataFinal = Convert.ToDateTime(dr[PROMOCAO.DATA_FINAL].ToString());
				promocao.DataInicial = Convert.ToDateTime(dr[PROMOCAO.DATA_INICIAL].ToString());
				promocao.MostrarRelogio = Convert.ToBoolean(dr[PROMOCAO.MOSTRAR_RELOGIO].ToString());
				promocao.PorcentagemOriginal = float.Parse(dr[PROMOCAO.PORCENTAGEM].ToString());
				promocao.ProdutoID = Convert.ToInt64(dr[PROMOCAO.PRODUTO_ID].ToString());
				promocao.ValorAjustado = Convert.ToDecimal(dr[PROMOCAO.VALOR_AJUSTADO].ToString());

				lstPromocao.Add(promocao);
			}

			return lstPromocao;
		}
		public static List<UsuarioClass> toUsuarioClass(this DataTable dt)
		{
			if (dt.isNull())
				return null;

			if (dt.Rows.Count == 0)
				return null;

			List<UsuarioClass> lstUsuario = new List<UsuarioClass>();

			foreach (DataRow dr in dt.Rows)
			{
				UsuarioClass usuario = new UsuarioClass();

				usuario.ID = Convert.ToInt32(dr[USUARIO.ID].ToString());
				usuario.Ativo = Convert.ToBoolean(dr[USUARIO.ATIVO].ToString());
				usuario.Email = dr[USUARIO.EMAIL].ToString();
				usuario.Login = dr[USUARIO.LOGIN].ToString();
				usuario.Nome = dr[USUARIO.NOME].ToString();
				usuario.Senha = dr[USUARIO.SENHA].ToString();
				usuario.Sexo = dr[USUARIO.SENHA].ToString();

				lstUsuario.Add(usuario);
			}

			return lstUsuario;
		}
		#endregion
	}
}